import {clone} from "@/common/util";
import {widgetType} from "@/uni_modules/u-form/components/u-form/map";
import {validateFun} from "@/uni_modules/u-form/components/u-form/validator";

/**
 * 初始化表单项
 * @param {array} form 表单数据
 * @param {object} props 组件的props数据
 * @param {function} t 国际化翻译函数
 * */
export const init = (form: FormInterface[], props: Record<string, any>, t: (key: string, p?: Record<string, any>) => string): FormItemInterface[] =>
{
    // 当前表单项
    const formItem: FormItemInterface[] = [];

    // 当前临时表单值
    const formTempValue: Record<string, any> = {};

    // 当前临时表单项数据
    const formTempItem: FormItemInterface[] = [];

    // 克隆当前表单数据
    const cloneForm: FormInterface[] = clone(form, true);

    // 解析当前表单数据
    cloneForm.forEach((item: FormInterface): void =>
    {
        // 解析当前表单基础信息
        const {type, label, field, required, placement, placeholder} = analysisBaseInfo(item, props, t);

        // 设置临时的表单值
        const {dataType, value} = analysisFormValue(item);

        // 设置临时表单值
        formTempValue[field] = value;

        // 需要填充占位信息
        if (placeholder)
        {
            if (item.componentProps)
            {
                item.componentProps["placeholder"] = placeholder;
            }
            else
            {
                item.componentProps = {
                    placeholder: placeholder
                };
            }
        }

        // 组装当前的表单项数据
        formTempItem.push({
            field: field,
            label: label,
            type: type,
            isShow: false,
            value: value,
            placement: placement,
            required: required,
            rules: item.rules || [],
            dataType: dataType,
            validate: true,
            message: "",
            componentProps: item.componentProps || {},
            customValidate: item.customValidate
        });
    });

    // 解析表单项数据
    const currentForm: FormInterface[] = cloneForm.filter((item: FormInterface, index: number) =>
    {
        // 解析是否存在
        item.ifShow = !(item.ifShow != null && (isBoolean(item.ifShow) && !item.ifShow || isFunction(item.ifShow) && item.ifShow.apply(item, [{current: item, form: cloneForm, formValue: formTempValue, index}]) === false));

        // 解析是否显示
        item.isShow = !(item.isShow != null && (isBoolean(item.isShow) && !item.isShow || isFunction(item.isShow) && item.isShow.apply(item, [{current: item, form: cloneForm, formValue: formTempValue, index}]) === false));

        return item.ifShow;
    });

    // 设置表单值
    currentForm.forEach((item: FormInterface) =>
    {
        // 判断是否存在对应的表单项
        if (Object.hasOwn(formTempValue, item.field))
        {
            // 设置表单项数据
            const currentFormItem = formTempItem.find((currentItem: FormItemInterface) =>
            {
                return currentItem.field === item.field;
            });

            if (currentFormItem)
            {
                formItem.push({
                    field: currentFormItem.field,
                    label: currentFormItem.label,
                    value: currentFormItem.value,
                    type: currentFormItem.type,
                    rules: currentFormItem.rules,
                    placement: currentFormItem.placement,
                    required: currentFormItem.required,
                    isShow: item.isShow as boolean, // 经过之前的类型转换，所以这里直接可以类型断言
                    dataType: currentFormItem.dataType,
                    validate: currentFormItem.validate,
                    message: currentFormItem.message,
                    componentProps: item.componentProps || {},
                    customValidate: item.customValidate
                });
            }
        }
    });

    return formItem;
};

/**
 * 合并表单值
 * @param form 表单数据
 * @returns {object} 表单值
 * */
export const mergeFormValue = (form: FormItemInterface[]): Record<string, any> =>
{
    return form.reduce((previousValue: FormItemInterface | Record<string, any>, currentValue: FormItemInterface) =>
    {
        return {...previousValue, [currentValue.field]: currentValue.value};

    }, {});
};

/**
 * 校验表单
 * @param form 表单数据
 * @param {function} t 国际化翻译函数
 * @param field 校验字段
 * */
export const validateForm = (form: FormItemInterface[], t: (key: string, p?: Record<string, any>) => string, field: string[] = []): Promise<Record<string, any>> =>
{
    return new Promise<Record<string, any>>((resolve, reject) =>
    {
        // 当前的所有Promise校验集合
        const validateArray: {field: string, validate: Promise<Record<string, any> | void>}[] = [];

        // 当前的表单值
        const formValue: Record<string, any> = {};

        // 当前需要校验校验的表单项
        form.filter((item: FormItemInterface) =>
        {
            // 当前需要校验的字段
            return item.field !== "custom" && (!isEmpty(field) && field.includes(item.field) || isEmpty(field));

        }).forEach((item: FormItemInterface) =>
        {
            // 当前表单项的值
            const value = item.value;

            // 当前表单项的标签名称
            const labelName = item.label;

            // 当前表单项的校验规则
            const rules: FormRuleInterface[] = item.rules;

            // 当前表单项的校验规则数量
            const ruleCount = rules.length;

            // 缓存当前表单值
            formValue[item.field] = value;

            // 只有存在规则才进行校验
            if (ruleCount > 0)
            {
                //  当前表单项的校验规则集合
                for (let i = 0; i < ruleCount; i++)
                {
                    const itemRule: Record<string, any> = rules[i];

                    for (const ruleKey in itemRule)
                    {
                        // 当前表单项的校验规则的key
                        let itemKey = "";

                        // 当前表单项的校验规则的value
                        let ruleValue: any;

                        // 当前表单项的校验规则的message
                        const message = itemRule.message;

                        // 标签
                        if (ruleKey === "ruleKey")
                        {
                            itemKey = itemRule[ruleKey];

                            // 如果不是多标签,但是为必填验证
                            if (!/\|/.test(itemKey) && itemKey === "required")
                            {
                                ruleValue = true;
                            }
                        }
                        else if (ruleKey !== "message")
                        {
                            itemKey = ruleKey;

                            ruleValue = itemRule[ruleKey];
                        }

                        if (itemKey)
                        {
                            // 判断当前的标签是否多验证标签
                            if (/\|/.test(itemKey))
                            {
                                // 拆分验证规则
                                const splitRule = itemKey.split(/\|/g);

                                // 循环验证规则
                                splitRule.forEach((currentRule: string) =>
                                {
                                    // 如果是必填,则验证规则值为true
                                    if (currentRule === "required")
                                    {
                                        ruleValue = true;
                                    }

                                    const validate = validateRules(value, currentRule, ruleValue, message, labelName, t);

                                    if (validate)
                                    {
                                        validateArray.push({
                                            field: item.field,
                                            validate: validate
                                        });
                                    }
                                });
                            }
                            else
                            {
                                const validate = validateRules(value, itemKey, ruleValue, message, labelName, t);

                                if (validate)
                                {
                                    validateArray.push({
                                        field: item.field,
                                        validate: validate
                                    });
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                // 如果没有规则，则直接返回一个Promise对象
                validateArray.push({
                    field: item.field,
                    validate: Promise.resolve()
                });
            }

            // 自定义验证
            if (item.customValidate && isFunction(item.customValidate))
            {
                const customFun = item.customValidate.apply(item, [value]);

                // 如果返回值为null或者为true，则表示校验通过
                if (customFun == null || isBoolean(customFun) && customFun)
                {
                    validateArray.push({
                        field: item.field,
                        validate: Promise.resolve()
                    });
                }
                // 如果返回值为Promise对象，则表示需要进一步校验
                else if (customFun instanceof Promise)
                {
                    validateArray.push({
                        field: item.field,
                        validate: new Promise<Record<string, any> | void>((currentResolve, currentReject) =>
                        {
                            customFun.then((res: boolean | string | void) =>
                            {
                                // 当前的验证结果
                                const currentValidate = res == null ? true : isBoolean(res) ? res : false;

                                if (currentValidate)
                                {
                                    currentResolve({
                                        status: true,
                                        message: ""
                                    });
                                }
                                else
                                {
                                    currentReject({
                                        status: false,
                                        message: isString(res) ? res : t("form.validateFail")
                                    });
                                }

                            }).catch((error: string | void) =>
                            {
                                currentReject({
                                    status: false,
                                    message: error || t("form.validateFail")
                                });
                            });
                        })
                    });
                }
                // 如果返回值为字符串，则表示校验不通过，并且当前的错误提示信息为自定义的错误信息
                else if (isString(customFun))
                {
                    validateArray.push({
                        field: item.field,
                        validate: Promise.reject({
                            status: false,
                            message: customFun
                        })
                    });
                }
                // 如果返回值为其他类型，则表示校验不通过，并且当前的错误提示信息为默认的错误信息
                else
                {
                    validateArray.push({
                        field: item.field,
                        validate: Promise.reject({
                            status: false,
                            message: t("form.validateFail")
                        })
                    });
                }
            }
        });

        if (validateArray.length)
        {
            // 当前需要校验的表单项数量
            let validateCount = validateArray.length;

            // 当前需要校验的表单项集合
            const promiseArray: Promise<Record<string, any> | void>[] = [];

            // 抽离字段以及校验器
            validateArray.forEach((item: {field: string, validate: Promise<Record<string, any> | void>}) =>
            {
                promiseArray.push(item.validate);
            });

            // 循环校验
            Promise.allSettled(promiseArray).then((result: Record<string, any>[]) =>
            {
                result.forEach((current: Record<string, any>, index: number) =>
                {
                    // 当前字段
                    const field = validateArray[index].field;

                    // 获取当前的表单项数据
                    const currentForm = form.find((item: FormItemInterface) =>
                    {
                        return item.field === field;
                    });

                    if (currentForm)
                    {
                        // 如果是fulfilled，则说明校验通过
                        if (current.status === "fulfilled")
                        {
                            validateCount--;
                        }
                        // 如果是rejected，则说明校验不通过
                        else
                        {
                            // 设置校验状态为false
                            currentForm.validate = false;

                            // 设置校验信息
                            currentForm.message = current.reason.message || "";
                        }
                    }
                });

            }).finally(() =>
            {
                if (validateCount === 0)
                {
                    resolve(formValue);
                }
                else
                {
                    reject();
                }
            });
        }
        // 不需要进行校验
        else
        {
            resolve(formValue);
        }
    });
};

/**
 * 更新表单项
 * @param {FormInterface | FormInterface[]} updateForm 需要更新的表单项
 * @param {FormInterface[]} form 表单数据
 * @param {FormItemInterface[]} formList 表单项数据
 * @param {Record<string, any>} props 组件的props
 * @param {Function} t 国际化函数
 * @param {string} operation 操作类型
 * @param {number | string} position 当前新增表单项的位置（只有操作类型为add时有效）
 * @param {string} modifiers 添加表单项位置的修饰符，如果position值为数字时，表示当前新增表单项的位置，如果position值为字符串，则表示当前新增表单项的位置的修饰符（before表示在当前位置之前，after表示在当前位置之后）
 * */
export const updateFormItem = (updateForm: FormInterface | FormInterface[], form: FormInterface[], formList: FormItemInterface[], props: Record<string, any>, t: (key: string, p?: Record<string, any>) => string, operation: "update" | "add" = "update", position?: number | string, modifiers?: "before" | "after"): Promise<Record<string, any>> =>
{
    return new Promise<Record<string, any>>((resolve, reject) =>
    {
        // 将参数转为数组
        updateForm = isArray(updateForm) ? updateForm : [updateForm];

        // 修改
        if (operation === "update")
        {
            // 当前需要更新的表单字段
            const updateFormFields: string[] = [];

            // 遍历参数
            updateForm.forEach((item: FormInterface) =>
            {
                // 当前对应的原始表单项
                const currentFormItem = form.find((currentItem: FormInterface) =>
                {
                    return currentItem.field === item.field;
                });

                if (currentFormItem)
                {
                    // 更新标签
                    if (item.label)
                    {
                        currentFormItem.label = item.label;
                    }

                    // 更新组件类型
                    if (item.component)
                    {
                        currentFormItem.component = item.component;
                    }

                    // 更新输出类型
                    if (item.outputType)
                    {
                        currentFormItem.outputType = item.outputType;
                    }

                    // 更新值
                    if (item.value != null)
                    {
                        currentFormItem.value = item.value;
                    }

                    // 更新校验规则
                    if (item.rules)
                    {
                        currentFormItem.rules = item.rules;
                    }

                    // 更新控件与插槽的布局方式
                    if (item.placement)
                    {
                        currentFormItem.placement = item.placement;
                    }

                    // 更新是否存在
                    if (item.ifShow != null)
                    {
                        currentFormItem.ifShow = item.ifShow;
                    }

                    // 更新是否显示
                    if (item.isShow != null)
                    {
                        currentFormItem.isShow = item.isShow;
                    }

                    // 更新组件的属性
                    if (item.componentProps)
                    {
                        currentFormItem.componentProps = item.componentProps;
                    }

                    // 缓存需要更新的表单字段
                    updateFormFields.push(currentFormItem.field);
                }
            });

            if (updateFormFields.length)
            {
                // 设置表单数据
                const newFormList = init(form, props, t);

                // 更具当前需要更新的字段，更新表单项
                updateFormFields.forEach((itemField: string) =>
                {
                    // 当前表单项的索引
                    const formIndex = formList.findIndex((item: FormItemInterface) =>
                    {
                        return item.field === itemField;
                    });

                    // 当前更新后的表单项
                    const targetFormItem = newFormList.find((item: FormItemInterface) =>
                    {
                        return item.field === itemField;
                    });

                    // 存在则更新
                    if (targetFormItem)
                    {
                        formList[formIndex] = targetFormItem;
                    }
                    // 不存在则删除
                    else
                    {
                        formList.splice(formIndex, 1);
                    }
                });

                resolve(mergeFormValue(formList));
            }
            else
            {
                reject({
                    message: "请传入正确的表单字段"
                });
            }
        }
        // 添加
        else
        {
            // 如果当前没有指定插入的位置，则默认插入到表单的最后
            position = position != null ? isNumber(position) ? position <= form.length ? position : form.length : position : form.length;

            // 如果当前没有指定插入的位置修饰符，则默认为after
            modifiers = modifiers || "after";

            // 设置表单数据
            const newFormList = init(updateForm, props, t);

            // 如果当前传入的position为数字，则表示当前需要插入的位置
            if (isNumber(position))
            {
                formList.splice(position, 0, ...newFormList);
            }
            else
            {
                // 找到当前需要插入的位置
                const positionIndex = formList.findIndex((item: FormItemInterface) =>
                {
                    return item.field === position;
                });

                if (positionIndex !== -1)
                {
                    if (modifiers === "before")
                    {
                        formList.splice(positionIndex, 0, ...newFormList);
                    }
                    else
                    {
                        formList.splice(positionIndex + 1, 0, ...newFormList);
                    }
                }
                else
                {
                    formList.push(...newFormList);
                }
            }

            resolve(mergeFormValue(formList));
        }
    });
};

/**
 * 对规则进行校验
 * @param value 当前表单项的值
 * @param ruleKey 当前表单项的规则key
 * @param ruleValue 当前表单项的规则value
 * @param message 当前表单项的规则message
 * @param labelName 当前表单项的标签名称
 * @param t 国际化函数
 * */
function validateRules(value: any, ruleKey: string, ruleValue: any, message: string, labelName: string, t: (key: string, p?: Record<string, any>) => string): Promise<{status: boolean, message: string}> | void
{
    // 首先判断是否为必填
    if (ruleKey === "required")
    {
        if (ruleValue)
        {
            let status: boolean;

            if (isString(value))
            {
                status = value !== "";
            }
            else if (isNumber(value))
            {
                status = true;
            }
            else if (isArray(value))
            {
                const itemValue = value as Array<any>;

                status = itemValue.length > 0;
            }
            else if (isObject(value))
            {
                const itemValue = value as Record<string, any>;

                status = !isEmpty(itemValue);
            }
            else
            {
                status = value != null;
            }

            // 这里的replace是为了兼容小程序下以及APP下的占位符替换问题
            return promiseFun(status, message ? message : labelName ? t("form.cannotEmpty", {name: labelName}).replace("{name}", labelName) : t("form.required"));
        }
    }
    // 验证的类型需要输入值
    else
    {
        // 当前值是否为空
        let isEmptyValue = true;

        if (isString(value) && value)
        {
            isEmptyValue = false;
        }
        else if (isNumber(value))
        {
            isEmptyValue = false;
        }
        else if (isArray(value))
        {
            const itemValue = value as Array<any>;

            isEmptyValue = itemValue.length === 0;
        }
        else if (isObject(value))
        {
            const itemValue = value as Record<string, any>;

            isEmptyValue = isEmpty(itemValue);
        }

        // 只有不为空才校验
        if (!isEmptyValue)
        {
            // 验证电话号码
            if (ruleKey === "phone")
            {
                if (isString(value) || isNumber(value))
                {
                    return promiseFun(validateFun.phone(value), message || t("form.phone"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证邮箱
            else if (ruleKey === "email")
            {
                if (isString(value))
                {
                    return promiseFun(validateFun.email(value), message || t("form.email"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证正整数
            else if (ruleKey === "positiveInteger")
            {
                if (isString(value) || isNumber(value))
                {
                    return promiseFun(validateFun.positiveInteger(value), message || t("form.positiveInteger"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非负数字
            else if (ruleKey === "unNegativeNumber")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.unNegativeNumber(value), message || t("form.unNegativeNumber"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非负整数
            else if (ruleKey === "nonnegativeInteger")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.nonnegativeInteger(value), message || t("form.nonnegativeInteger"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证负整数
            else if (ruleKey === "negativeInteger")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.negativeInteger(value), message || t("form.negativeInteger"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非零整数
            else if (ruleKey === "nonzeroInteger")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.nonzeroInteger(value), message || t("form.nonzeroInteger"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证数字
            else if (ruleKey === "number")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.number(value), message || t("form.number"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证浮点数
            else if (ruleKey === "float")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.float(value), message || t("form.float"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非零浮点数
            else if (ruleKey === "nonzeroFloat")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.nonzeroFloat(value), message || t("form.nonzeroFloat"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证正浮点数
            else if (ruleKey === "positiveFloat")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.positiveFloat(value), message || t("form.positiveFloat"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证负浮点数
            else if (ruleKey === "negativeFloat")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.negativeFloat(value), message || t("form.negativeFloat"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非零正浮点数
            else if (ruleKey === "nonzeroPositiveFloat")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.nonzeroPositiveFloat(value), message || t("form.nonzeroPositiveFloat"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非零负浮点数
            else if (ruleKey === "nonzeroNegativeFloat")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.nonzeroNegativeFloat(value), message || t("form.nonzeroNegativeFloat"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证非零负浮点数
            else if (ruleKey === "integerDecimalNumber")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    return promiseFun(validateFun.integerDecimalNumber(value), message || t("form.integerDecimalNumber"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证中文或字母
            else if (ruleKey === "alphabet")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.alphabet(value), message || t("form.alphabet"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证min
            else if (ruleKey === "min")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    if (typeof value === "string")
                    {
                        if (isNaN(Number(value)))
                        {
                            return promiseFun(false, t("form.number"));
                        }

                        value = Number(value);
                    }

                    return promiseFun(validateFun.min(value, ruleValue), message || t("form.min", {min: ruleValue}).replace("{min}", ruleValue));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证max
            else if (ruleKey === "max")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    if (typeof value === "string")
                    {
                        if (isNaN(Number(value)))
                        {
                            return promiseFun(false, t("form.number"));
                        }

                        value = Number(value);
                    }

                    return promiseFun(validateFun.max(value, ruleValue), message || t("form.max", {max: ruleValue}).replace("{max}", ruleValue));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证minLength
            else if (ruleKey === "minLength")
            {
                if (typeof value === "string" || typeof value === "number" || Array.isArray(value))
                {
                    return promiseFun(validateFun.minLength(value, ruleValue), message || t("form.minLength", {min: ruleValue}).replace("{min}", ruleValue));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证maxLength
            else if (ruleKey === "maxLength")
            {
                if (typeof value === "string" || typeof value === "number" || Array.isArray(value))
                {
                    return promiseFun(validateFun.maxLength(value, ruleValue), message || t("form.maxLength", {max: ruleValue}).replace("{max}", ruleValue));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证between
            else if (ruleKey === "between")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    const split = ruleValue.split("-");

                    let start = split[0];

                    let end = split[1];

                    if (!start || !end)
                    {
                        return promiseFun(false, t("form.betweenTip"));
                    }

                    if (isNaN(Number(start)) || isNaN(Number(end)))
                    {
                        return promiseFun(false, t("form.betweenTip"));
                    }
                    else
                    {
                        start = Number(start);

                        end = Number(end);
                    }

                    if (typeof value === "string")
                    {
                        if (isNaN(Number(value)))
                        {
                            return promiseFun(false, t("form.number"));
                        }

                        value = Number(value);
                    }

                    return promiseFun(validateFun.between(value, start, end), message || t("form.between", {start: split[0], end: split[1]}).replace("{start}", split[0]).replace("{end}", split[1]));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证date
            else if (ruleKey === "date")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.date(value), message || t("form.date"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证time
            else if (ruleKey === "time")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.time(value), message || t("form.time"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证dateTime
            else if (ruleKey === "dateTime")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.dateTime(value), message || t("form.dateTime"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证身份证
            else if (ruleKey === "identityCard")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    if (typeof value === "number")
                    {
                        value = value.toString();
                    }

                    return promiseFun(validateFun.identityCard(value), message || t("form.identityCard"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证特殊字符
            else if (ruleKey === "special")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.special(value), message || t("form.special"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证特殊字符（简易）
            else if (ruleKey === "simpleSpecial")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.simpleSpecial(value), message || t("form.special"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证数字和字母
            else if (ruleKey === "letterNumber")
            {
                if (typeof value === "string")
                {
                    return promiseFun(validateFun.letterNumber(value), message || t("form.letterNumber"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证浮点数精度
            else if (ruleKey === "precision")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    if (typeof value === "number")
                    {
                        value = value.toString();
                    }

                    return promiseFun(validateFun.precision(value, ruleValue), message || t("form.precision", {precision: ruleValue}).replace("{precision}", ruleValue));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证护照
            else if (ruleKey === "passport")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    if (typeof value === "number")
                    {
                        value = value.toString();
                    }

                    return promiseFun(validateFun.passport(value), message || t("form.passport"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            // 验证regular
            else if (ruleKey === "regular")
            {
                if (typeof value === "string" || typeof value === "number")
                {
                    if (typeof value === "number")
                    {
                        value = value.toString();
                    }

                    return promiseFun(validateFun.regular(value, ruleValue), message || t("form.regular"));
                }
                else
                {
                    return promiseFun(false, t("form.typeError"));
                }
            }
            else
            {
                return promiseFun(false, t("form.typeError"));
            }
        }
    }
}

/**
 * 构造Promise对象
 * @param {string | boolean} status 当前的状态信息
 * @param {string} message 当前出错返回的错误提示
 * */
function promiseFun(status: string | boolean, message: string): Promise<{status: boolean, message: string}>
{
    return new Promise((resolve, reject) =>
    {
        if (isString(status))
        {
            reject({
                status: false,
                message: status
            });
        }
        else
        {
            if (status)
            {
                resolve({
                    status,
                    message
                });
            }
            else
            {
                reject({
                    status,
                    message
                });
            }
        }
    });
}

/**
 * 解析表单基础信息
 * @param {object} form 表单数据
 * @param {object} props 组件的props
 * @param {function} t 语言包
 * @return {object} 表单基础信息
 * */
function analysisBaseInfo(form: FormInterface, props: Record<string, any>, t: (key: string, p?: Record<string, any>) => string): {type: string, label: string, field: string, required: boolean, placement: DirectionType, placeholder: string}
{
    // 当前表单类型（这里如果不设置表单类型，则默认为Input输入框）
    const type: string = widgetType[form.component || "Input"];

    // 当前表单标题
    const label: string = form.label || "";

    // 当前表单字段
    const field: string = form.field || "";

    // 当前控件与插槽的布局方式
    const placement: DirectionType = form.placement || "horizontal";

    // 当前表单项是否必填
    let required = false;

    // 当前表单验证规则
    const rules: FormRuleInterface[] = form.rules || [];

    // 当前表单的占位信息
    let placeholder: string = "";

    // 判断是否存在必填规则
    rules.forEach((item: FormRuleInterface) =>
    {
        if (item.required === true || item.ruleKey && item.ruleKey.indexOf("required") >= 0)
        {
            required = true;
        }
    });

    // 是否开启自动占位
    if (props.autoPlaceholder && ["Input", "InputPassword", "InputNumber", "InputIdCard", "InputDigit", "InputTel", "Textarea"].includes(form.component) && (!form.componentProps || form.componentProps && !form.componentProps.placeholder))
    {
        placeholder = t("form.placeholder", {name: form.label || ""}).replace("{name}", form.label || "");
    }

    return {type, label, field, required, placement, placeholder};
}

/**
 * 解析当前表单项的值
 * @param {object} form 表单数据
 * @return {object} 表单值
 * */
function analysisFormValue(form: FormInterface): {dataType: FormValueType, value: any}
{
    // 当前表单项的校验类型
    const type: FormValueType = form.outputType || getDataTypeByComponent(form.component);

    // 当前表单值
    const value = form.value != null ? form.value : "";

    // 当前处理后的表单值
    let copeValue: Record<string, any>;

    // 校验字符串
    if (type === "string")
    {
        copeValue = getFormValue(value != null ? value : "", form, type);
    }
    // 校验数字
    else if (type === "number")
    {
        copeValue = getFormValue(value != null ? value : null, form, type);
    }
    // 校验布尔值
    else if (type === "boolean")
    {
        copeValue = getFormValue(value != null ? value : false, form, type);
    }
    // 校验数组
    else if (type === "array")
    {
        copeValue = getFormValue(value != null ? value : [], form, type);
    }
    // 校验对象
    else if (type === "object")
    {
        copeValue = getFormValue(value != null ? value : {}, form, type);
    }
    // 其他
    else
    {
        copeValue = getFormValue(value != null ? value : "", form, type);
    }

    return {
        dataType: copeValue.transformType || type,
        value: copeValue.value
    };
}

/**
 * 获取表单项的值
 * @param {any} value 表单值
 * @param {object} form 表单数据
 * @param {string} type 表单类型
 * @return {any} 处理后的表单值
 * */
function getFormValue(value: any, form: FormInterface, type: FormValueType): {value: any, transformType: FormValueType | null}
{
    // 当前的值
    let copeValue: any = value;

    // 当前纠正的类型
    let transformType: FormValueType | null = null;

    // checkboxGroup组件特殊处理
    if (["CheckboxGroup"].includes(form.component))
    {
        // 是否为空值
        let isEmptyValue = false;

        if ((!isString(copeValue) || !isArray(copeValue)) && (copeValue === null || copeValue === undefined || isString(copeValue) && copeValue === "" || isArray(copeValue) && copeValue.length === 0))
        {
            isEmptyValue = true;
        }

        // 如果为空值，则需要设置当前组件的值为空数组
        if (isEmptyValue)
        {
            copeValue = [];
        }
        else if (!isArray(copeValue))
        {
            copeValue = [copeValue];
        }

        // 强制纠正类型，这里纠正类型是根据传递的原始值类型，来确定当前组件的值类型
        transformType = "array";
    }
    // radioGroup组件特殊处理
    else if (["RadioGroup"].includes(form.component))
    {
        // 是否为空值
        let isEmptyValue = false;

        // 判断是否为空值
        if (copeValue === null || copeValue === undefined || copeValue === "")
        {
            isEmptyValue = true;
        }

        // 因为radioGroup组件不允许有空值，如果是空值，则需要设置当前第一位元素的value值作为当前组件的值
        if (isEmptyValue)
        {
            // 当前的值对应的映射
            const valueTag: string = form.componentProps?.valueTag || "value";

            // 当前的选项
            const options: Record<string, any>[] = form.componentProps?.options || [];

            if (options && options.length)
            {
                copeValue = options[0][valueTag];
            }

            warn("[u-form] radioGroup组件不允许有空值，当前组件的值为空，将设置当前第一位元素的value值作为当前组件的值");
        }

        // 强制纠正类型，这里纠正类型是根据传递的原始值类型，来确定当前组件的值类型
        if (isString(copeValue) && type !== "string")
        {
            transformType = "string";
        }
        else if (isNumber(copeValue) && type !== "number")
        {
            transformType = "number";
        }
    }
    // Input组件、InputTel组件、InputIdCard组件、InputPassword组件特殊处理（使用Input组件、InputTel组件、InputIdCard组件、InputPassword组件将不会得到Number类型的值，如果需要得到Number类型的值需要使用InputNumber组件）
    else if (["Input", "InputTel", "InputIdCard", "InputPassword"].includes(form.component))
    {
        // 当前组件下需要强制纠正类型
        if (type !== "string")
        {
            // 当前组件下需要强制纠正类型
            transformType = getDataTypeByComponent(form.component);

            warn(`[u-form] ${form.field}字段值类型与组件输出值类型不一致，使用Input组件、InputTel组件、InputIdCard组件、InputPassword组件，将不会得到Number类型的值，如果需要得到Number类型的值需要使用InputNumber组件`);
        }

        if (isNumber(value))
        {
            copeValue = value.toString();
        }
        else
        {
            copeValue = value;
        }
    }
    // InputNumber组件以及InputDigit组件特殊处理（使用InputNumber组件、InputDigit组件将不会得到String类型的值，如果需要得到String类型的值需要使用Input组件）
    else if (["InputNumber", "InputDigit"].includes(form.component))
    {
        // 当前组件下需要强制纠正类型
        if (type !== "number")
        {
            // 当前组件下需要强制纠正类型
            transformType = getDataTypeByComponent(form.component);

            warn(`[u-form] ${form.field}字段值类型与组件输出值类型不一致，使用InputNumber组件、InputDigit组件，将不会得到String类型的值，如果需要得到String类型的值需要使用Input组件`);
        }

        if (isString(value))
        {
            if (value)
            {
                copeValue = Number(value);
            }
            else
            {
                copeValue = null;
            }
        }
        else
        {
            copeValue = value;
        }
    }
    // 自定义组件特殊处理（使用自定义组件一律返回的值为null，因为自定义组件的值无从考究）
    else if (["Custom"].includes(form.component))
    {
        // 当前组件下需要强制纠正类型
        transformType = getDataTypeByComponent(form.component);

        // 自定义组件的值无从考究，统一返回null
        copeValue = null;
    }

    return {value: copeValue, transformType};
}

/**
 * 根据当前组件获取对应的数据类型
 * @param {string} componentType 组件类型
 * @return {string} 数据类型
 * */
function getDataTypeByComponent(componentType: FormComponentType): FormValueType
{
    // 当前对应组件的值类型
    let dataType: FormValueType = "string";

    // 文本输入框组件对应只有字符串类型
    if (["Input", "InputTel", "InputIdCard", "InputPassword"].includes(componentType))
    {
        dataType = "string";
    }
    // 数字输入框组件对应只有数字类型
    else if (["InputNumber", "InputDigit"].includes(componentType))
    {
        dataType = "number";
    }
    // 自定义组件对应任何类型
    else if (["Custom"].includes(componentType))
    {
        dataType = "any";
    }

    return dataType;
}